#include "HashTable.hpp"

namespace Myunordered_set
{
    template <class K, class Hash = HashFunc<K>>
    class unordered_set
    {
        struct SetKeyOfT
        {
            const K &operator()(const K &key)
            {
                return key;
            }
        };

    public:
        typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::iterator iterator;
        typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::const_iterator const_iterator;
        iterator begin()
        {
            return _ht.begin();
        }

        iterator end()
        {
            return _ht.end();
        }

        const_iterator begin() const
        {
            return _ht.begin();
        }

        const_iterator end() const
        {
            return _ht.end();
        }

        std::pair<iterator, bool> insert(const K &key)
        {
            return _ht.Insert(key);
        }

        iterator find(const K &key)
        {
            return _ht.Find(key);
        }

        bool erase(const K &key)
        {
            return _ht.Erase(key);
        }

        size_t size() const
        {
            return _ht.size();
        }

        bool empty() const
        {
            return _ht.empty();
        }

    private:
        hash_bucket::HashTable<K, const K, SetKeyOfT, Hash> _ht;
    };

    void test_unordered_set()
    {
        unordered_set<int> s;
        s.insert(31);
        s.insert(11);
        s.insert(5);
        s.insert(15);
        s.insert(25);

        unordered_set<int>::iterator it = s.begin();
        std::cout << s.empty() << std::endl;
        std::cout << s.size() << std::endl;
        while (it != s.end())
        {
            //*it = 1;
            std::cout << *it << " ";
            ++it;
        }
        std::cout << std::endl;

        for (auto e : s)
        {
            std::cout << e << " ";
        }
        std::cout << std::endl;
    }
}